16 research outputs found
Handling Non-Unitaries in Quantum Circuit Equivalence Checking
Quantum computers are reaching a level where interactions between classical
and quantum computations can happen in real-time. This marks the advent of a
new, broader class of quantum circuits: dynamic quantum circuits. They offer a
broader range of available computing primitives that lead to new challenges for
design tasks such as simulation, compilation, and verification. Due to the
non-unitary nature of dynamic circuit primitives, most existing techniques and
tools for these tasks are no longer applicable in an out-of-the-box fashion. In
this work, we discuss the resulting consequences for quantum circuit
verification, specifically equivalence checking, and propose two different
schemes that eventually allow to treat the involved circuits as if they did not
contain non-unitaries at all. As a result, we demonstrate methodically, as well
as, experimentally that existing techniques for verifying the equivalence of
quantum circuits can be kept applicable for this broader class of circuits.Comment: 7 pages, 4 figures, old title: "Towards Verification of Dynamic
Quantum Circuits", revised manuscript, added experimental result
Reducing the Compilation Time of Quantum Circuits Using Pre-Compilation on the Gate Level
In order to implement a quantum computing application, problem instances must
be encoded into a quantum circuit and then compiled for a specific platform.
The lengthy compilation process is a key bottleneck in this workflow,
especially for problems that arise repeatedly with a similar yet distinct
structure (each of which requires a new compilation run thus far). In this
paper, we aim to overcome this bottleneck by proposing a comprehensive
pre-compilation technique that tries to minimize the time spent for compiling
recurring problems while preserving the solution quality as much as possible.
The following concepts underpin the proposed approach: Beginning with a problem
class and a corresponding quantum algorithm, a predictive encoding scheme is
applied to encode a representative problem instance into a general-purpose
quantum circuit for that problem class. Once the real problem instance is
known, the previously constructed circuit only needs to be adjusted -- with
(nearly) no compilation necessary. Experimental evaluations on QAOA for the
MaxCut problem as well as a case study involving a satellite mission planning
problem show that the proposed approach significantly reduces the compilation
time by several orders of magnitude compared to Qiskit's compilation schemes
while maintaining comparable compiled circuit quality. All implementations are
available on GitHub (https://github.com/cda-tum/mqt-problemsolver) as part of
the Munich Quantum Toolkit (MQT).Comment: 11 pages, 8 Figures, minor changes, to be published at International
Conference on Quantum Computing and Engineering (QCE), 202
Compiler Optimization for Quantum Computing Using Reinforcement Learning
Any quantum computing application, once encoded as a quantum circuit, must be
compiled before being executable on a quantum computer. Similar to classical
compilation, quantum compilation is a sequential process with many compilation
steps and numerous possible optimization passes. Despite the similarities, the
development of compilers for quantum computing is still in its infancy-lacking
mutual consolidation on the best sequence of passes, compatibility,
adaptability, and flexibility. In this work, we take advantage of decades of
classical compiler optimization and propose a reinforcement learning framework
for developing optimized quantum circuit compilation flows. Through distinct
constraints and a unifying interface, the framework supports the combination of
techniques from different compilers and optimization tools in a single
compilation flow. Experimental evaluations show that the proposed framework-set
up with a selection of compilation passes from IBM's Qiskit and Quantinuum's
TKET-significantly outperforms both individual compilers in over 70% of cases
regarding the expected fidelity. The framework is available on GitHub
(https://github.com/cda-tum/MQTPredictor).Comment: 6 pages, 3 figure
On Optimal Subarchitectures for Quantum Circuit Mapping
Compiling a high-level quantum circuit down to a low-level description that
can be executed on state-of-the-art quantum computers is a crucial part of the
software stack for quantum computing. One step in compiling a quantum circuit
to some device is quantum circuit mapping, where the circuit is transformed
such that it complies with the architecture's limited qubit connectivity.
Because the search space in quantum circuit mapping grows exponentially in the
number of qubits, it is desirable to consider as few of the device's physical
qubits as possible in the process. Previous work conjectured that it suffices
to consider only subarchitectures of a quantum computer composed of as many
qubits as used in the circuit. In this work, we refute this conjecture and
establish criteria for judging whether considering larger parts of the
architecture might yield better solutions to the mapping problem. We show that
determining subarchitectures that are of minimal size, i.e., of which no
physical qubit can be removed without losing the optimal mapping solution for
some quantum circuit, is a very hard problem. Based on a relaxation of the
criteria for optimality, we introduce a relaxed consideration that still
maintains optimality for practically relevant quantum circuits. Eventually,
this results in two methods for computing near-optimal sets of
subarchitectures\unicode{x2014}providing the basis for efficient quantum
circuit mapping solutions. We demonstrate the benefits of this novel method for
state-of-the-art quantum computers by IBM, Google and Rigetti.Comment: 19 pages, 9 figures, 3 table
Mapping Quantum Circuits to IBM QX Architectures Using the Minimal Number of SWAP and H Operations
The recent progress in the physical realization of quantum computers (the
first publicly available ones--IBM's QX architectures--have been launched in
2017) has motivated research on automatic methods that aid users in running
quantum circuits on them. Here, certain physical constraints given by the
architectures which restrict the allowed interactions of the involved qubits
have to be satisfied. Thus far, this has been addressed by inserting SWAP and H
operations. However, it remains unknown whether existing methods add a minimum
number of SWAP and H operations or, if not, how far they are away from that
minimum--an NP-complete problem. In this work, we address this by formulating
the mapping task as a symbolic optimization problem that is solved using
reasoning engines like Boolean satisfiability solvers. By this, we do not only
provide a method that maps quantum circuits to IBM's QX architectures with a
minimal number of SWAP and H operations, but also show by experimental
evaluation that the number of operations added by IBM's heuristic solution
exceeds the lower bound by more than 100% on average. An implementation of the
proposed methodology is publicly available at
http://iic.jku.at/eda/research/ibm_qx_mapping
Verifying Results of the IBM Qiskit Quantum Circuit Compilation Flow
Realizing a conceptual quantum algorithm on an actual physical device
necessitates the algorithm's quantum circuit description to undergo certain
transformations in order to adhere to all constraints imposed by the hardware.
In this regard, the individual high-level circuit components are first
synthesized to the supported low-level gate-set of the quantum computer, before
being mapped to the target's architecture---utilizing several optimizations in
order to improve the compilation result. Specialized tools for this complex
task exist, e.g., IBM's Qiskit, Google's Cirq, Microsoft's QDK, or Rigetti's
Forest. However, to date, the circuits resulting from these tools are hardly
verified, which is mainly due to the immense complexity of checking if two
quantum circuits indeed realize the same functionality. In this paper, we
propose an efficient scheme for quantum circuit equivalence
checking---specialized for verifying results of the IBM Qiskit quantum circuit
compilation flow. To this end, we combine characteristics unique to quantum
computing, e.g., its inherent reversibility, and certain knowledge about the
compilation flow into a dedicated equivalence checking strategy. Experimental
evaluations confirm that the proposed scheme allows to verify even large
circuit instances with tens of thousands of operations within seconds or even
less, whereas state-of-the-art techniques frequently time-out or require
substantially more runtime. A corresponding open source implementation of the
proposed method is publicly available at https://github.com/iic-jku/qcec.Comment: 10 pages, to be published at International Conference on Quantum
Computing and Engineering (QCE20
Towards an Automated Framework for Realizing Quantum Computing Solutions
Quantum computing is fast evolving as a technology due to recent advances in
hardware, software, as well as the development of promising applications. To
use this technology for solving specific problems, a suitable quantum algorithm
has to be determined, the problem has to be encoded in a form suitable for the
chosen algorithm, it has to be executed, and the result has to be decoded. To
date, each of these tedious and error-prone steps is conducted in a mostly
manual fashion. This creates a high entry barrier for using quantum computing
-- especially for users with little to no expertise in that domain. In this
work, we envision a framework that aims to lower this entry barrier by allowing
users to employ quantum computing solutions in an automatic fashion. To this
end, interfaces as similar as possible to classical solvers are provided, while
the quantum steps of the workflow are shielded from the user as much as
possible by a fully automated backend. To demonstrate the feasibility and
usability of such a framework, we provide proof-of-concept implementations for
two different classes of problems which are publicly available on GitHub
(https://github.com/cda-tum/MQTProblemSolver). By this, this work provides the
foundation for a low-threshold approach of realizing quantum computing
solutions with no or only moderate expertise in this technology.Comment: 6 pages, 4 figure
Tensor Networks or Decision Diagrams? Guidelines for Classical Quantum Circuit Simulation
Classically simulating quantum circuits is crucial when developing or testing
quantum algorithms. Due to the underlying exponential complexity, efficient
data structures are key for performing such simulations. To this end, tensor
networks and decision diagrams have independently been developed with differing
perspectives, terminologies, and backgrounds in mind. Although this left
designers with two complementary data structures for quantum circuit
simulation, thus far it remains unclear which one is the better choice for a
given use case. In this work, we (1) consider how these techniques approach
classical quantum circuit simulation, and (2) examine their (dis)similarities
with regard to their most applicable abstraction level, the desired simulation
output, the impact of the computation order, and the ease of distributing the
workload. As a result, we provide guidelines for when to better use tensor
networks and when to better use decision diagrams in classical quantum circuit
simulation.Comment: 7 pages, 4 figures, comments welcom
SyReC Synthesizer: An MQT tool for synthesis of reversible circuits
Reversible circuits form the backbone for many promising emerging
technologies such as quantum computing, low power/adiabatic design,
encoder/decoder devices, and several other applications. In the recent years,
the scalable synthesis of such circuits has gained significant attention. In
this work, we present the SyReC Synthesizer, a synthesis tool for reversible
circuits based on the hardware description language SyReC. SyReC allows to
describe reversible functionality at a high level of abstraction. The provided
SyReC Synthesizer then realizes this functionality in a push-button fashion.
Corresponding options allow for a trade-off between the number of needed
circuit signals/lines (relevant, e.g., for quantum computing in which every
circuit line corresponds to a qubit) and the respectively needed gates
(corresponding to the circuit's costs). Furthermore, the tool allows to
simulate the resulting circuit as well as to determine the gate costs of it.
The SyReC Synthesizer is available as an open-source software package at
https://github.com/cda-tum/syrec as part of the Munich Quantum Toolkit (MQT).Comment: 6 pages, 3 figures, Software Impacts Journa